package com.cyys.common.services;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.cyys.common.dataScope.DataScope;
import com.cyys.common.mapper.CyysBaseMapper;
import com.cyys.common.model.BaseBean;
import com.cyys.common.ql.AR;
import com.cyys.common.utils.StringUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.Arrays;
import java.util.List;


@Transactional(readOnly = true)
public abstract class CyysBaseService<D extends CyysBaseMapper<T>, T extends BaseBean> extends BaseService {
	/**
	 * 持久层对象
	 */
	@Autowired
	protected D dao;

	/**
	 * 保存对象，
	 * 
	 * @param entity
	 * @return  AjaxJson
	 */
	@Transactional(readOnly = false)
	public AR save(T entity){
		return AR.ok(dao.insert(entity),"保存成功");
	}

	/**
	 * 修改对象
	 * 
	 * @param entity
	 */
	@Transactional(readOnly = false)
	public AR update(T entity){
		return AR.ok(dao.updateById(entity),"更新成功");
	}

	/**
	 * 获取单个对象
	 * 
	 * @param id
	 *            null,查询所有数据 0:查询未删除的数据,1:查询已删除的数据
	 * @return
	 */
	public T getById(String id) {
		return dao.selectById(id);
	}

	/**
	 * 根据条件查询数据
	 * @param queryWrapper
	 *            null,查询所有数据 0:查询未删除的数据,1:查询已删除的数据
	 * @return
	 */
	public IPage<T> list(Page page, QueryWrapper<T> queryWrapper, Boolean orderByDate) {
		if(orderByDate != null && orderByDate)
			queryWrapper.orderByDesc("date_create");
		return dao.selectPage(page, queryWrapper);
	}

	/**
	 * 查询所有数据
	 * 
	 * null,查询所有数据 0:查询未删除的数据,1:查询已删除的数据
	 * @return
	 * @
	 */
	public List<T> listAll(Wrapper<T> queryWrapper) {
		return dao.selectList(queryWrapper);
	}
	
	

	/**
	 * 根据编号删除用户
	 * 
	 * @param id
	 */
	@Transactional(readOnly = false)
	public AR deleteById(String id) {
		if (StringUtil.isBlank(id)){
			return AR.failed("删除时ID不能为空");
		}else{
			dao.deleteById(id);
			return AR.ok("删除成功");
		}
	}

	/**
	 * 根据编号数组删除用户
	 * 
	 * @param ids
	 */
	@Transactional(readOnly = false)
	public AR deleteBatchIds(String ids) {
		if (StringUtil.isBlank(ids)){
			return AR.failed("删除时ID不能为空");
		}else{
			String[] idsInt = ids.split(",");
			dao.deleteBatchIds(Arrays.asList(idsInt));
			return AR.ok("删除成功");
		}
	}



	/******根据权限进行查询********/
	/**
	 * 根据条件查询数据
	 * @param queryWrapper
	 *            null,查询所有数据 0:查询未删除的数据,1:查询已删除的数据
	 * @return
	 */
	public IPage<T> selectPageByScope(Page page, QueryWrapper<T> queryWrapper, DataScope scope) {
		return dao.selectPageByScope(page, queryWrapper, scope);
	}


	/**
	 * 查询所有数据
	 *
	 * null,查询所有数据 0:查询未删除的数据,1:查询已删除的数据
	 * @return
	 * @
	 */
	public List<T> selectListByScope(Wrapper<T> queryWrapper, DataScope scope) {
		return dao.selectListByScope(queryWrapper,scope);
	}


	/**
	 * 根据 Wrapper 条件，查询总记录数
	 * @param queryWrapper 实体对象封装操作类（可以为 null）
	 * @param scope 数据权限范围
	 * @return Integer
	 */
	int selectCountByScope(Wrapper<T> queryWrapper, DataScope scope){
		return dao.selectCountByScope(queryWrapper,scope);
	}

	/**
	 * 批量插入 仅适用于 mysql
	 * @param entityList 实体列表
	 * @return 影响行数
	 */
	@Transactional(readOnly = false)
	AR insertBatchSomeColumn(List<T> entityList){
		return AR.ok(dao.insertBatchSomeColumn(entityList));
	}
}
